#!/usr/bin/env python
# -*- coding: utf-8 -*-
#Importacion de modulos
import pygtk
pygtk.require('2.0')
import gtk, gtk.glade, inspect, sys, subprocess, os, string, UserList,commands
#from MatematicaBraille import Traductor
#from CastellanoBraille import Castellano
from ConfigurarTraductor import config
#from popen2 import popen2
from subprocess import *
from os import environ
import gtksourceview2 as gtkview
import xml.dom.minidom as minidom
#from ElegirTraduccion import Entrada
#rc_parser("Estilo")
MAIN_TAG = 0
CONTENT_TAG = 1
TITLE_TAG = 2
TEXT_TAG = 3

class Util:
    _xml_tags = {
	MAIN_TAG : "Traductor"
	, CONTENT_TAG: "Content"
	, TITLE_TAG : "Title"
	, TEXT_TAG : "Text"
    }
    def __init__(self,buf,buffer1,clipboard,Traductor,Texto,Texto_Traduccion,Titulo_Traduccion):

	#Se importa el archivo .glade
	self.w_tree = gtk.glade.XML('/usr/local/share/Lazarillo/Interfaz.glade')
	self.Traductor1 = self.w_tree.get_widget('Traductor')

	# Area de edicion de texto
	self.buffer = gtkview.Buffer()
	self.Texto = gtkview.View(self.buffer)
	self.display = gtk.gdk.display_manager_get().get_default_display()
	self.clipboard = gtk.Clipboard(self.display, "CLIPBOARD")
	
	#Ventana Acerca de
	self.Acerca_de = self.w_tree.get_widget ('Acerca_de')
	self.Acerca_de.set_icon_from_file("/usr/local/share/pixmaps/Lazarillo.png")

	#Ventana de Ayuda
	self.M_Ayuda = self.w_tree.get_widget ('M_Ayuda')
	self.M_Ayuda.set_icon_from_file("/usr/local/share/pixmaps/Lazarillo.png")
	self._Ayuda = self.w_tree.get_widget ('_Ayuda')
	self.Cerrar = self.w_tree.get_widget ('Cerrar')
	self.buffer_cont = gtkview.Buffer()
	self._Ayuda.set_buffer(self.buffer_cont)

	# Ventana de preguntas
	self.Preguntas = self.w_tree.get_widget ('Preguntas')
	self.Preguntas.set_icon_from_file("/usr/local/share/pixmaps/Lazarillo.png")
		
	#Ventana de error
	self.Error = self.w_tree.get_widget ('Error')
	self.Error.set_icon_from_file("/usr/local/share/pixmaps/Lazarillo.png")
	
	#Ventana de preguntas con botón aceptar configurado
	self.Pregunta_accion = self.w_tree.get_widget ('Pregunta_accion')
	self.Pregunta_accion.set_icon_from_file("/usr/local/share/pixmaps/Lazarillo.png")
	self.Cancelar_P = self.w_tree.get_widget ('Cancelar_P')
	self.Aceptar_P = self.w_tree.get_widget ('Aceptar_P')

	#Ventana de pregunta para salir sin guardar o guardar el documento
	self.Salir_Guardar = self.w_tree.get_widget ('Salir_Guardar')
	self.Salir_Guardar.set_icon_from_file("/usr/local/share/pixmaps/Lazarillo.png")
	self.Si = self.w_tree.get_widget ('Si')
	self.No = self.w_tree.get_widget ('No')
	self.Descartar = self.w_tree.get_widget ('Descartar')

	#Ventana para cambiar traducción desde la aplicación
	self.Cambiar_Traduccion = self.w_tree.get_widget('Cambiar_Traduccion')
	self.Cambiar_Traduccion.set_icon_from_file("/usr/local/share/pixmaps/Lazarillo.png")
	self.Traducir_Texto = self.w_tree.get_widget('Traducir_Texto1')
	self.Traducir_Operaciones_Matematicas = self.w_tree.get_widget('Traducir_Operaciones_Matematicas1')
	self.Acept = self.w_tree.get_widget('Acept1')
	self.Cancel = self.w_tree.get_widget('Cancel1')
	
	#Ventana de Elegir Perfil
	self.Elegir_Perfil = self.w_tree.get_widget ('Elegir_Perfil')
	self.Elegir_Perfil.set_icon_from_file("/usr/local/share/pixmaps/Lazarillo.png")
	self.Usuario_Invidente = self.w_tree.get_widget('Usuario_Invidente')
	self.Usuario_Baja_V = self.w_tree.get_widget('Usuario_Baja_V')
	self.Usuario_Vidente = self.w_tree.get_widget('Usuario_Vidente')
	self.Acepta = self.w_tree.get_widget ('Acepta')

	#Ventana de ir a línea
	self.V_Ir_a = self.w_tree.get_widget ('V_Ir_a')
	self.V_Ir_a.set_icon_from_file("/usr/local/share/pixmaps/Lazarillo.png")
	self.Entrada_num = self.w_tree.get_widget ('Entrada_num')
	self.Cancelar3 = self.w_tree.get_widget ('Cancelar3')
	self.Aceptar3 = self.w_tree.get_widget ('Aceptar3')

	#Conectando todas las señales
	self.w_tree.signal_autoconnect(dict(inspect.getmembers(self)))
	
	#Para los parámetros
	self.buffer = buf
	self.buffer1 = buffer1
	self.clipboard = clipboard
	self.Texto = Texto
	self.Traductor1 = Traductor
	self.Texto_Traduccion = Texto_Traduccion
	self.Titulo_Traduccion = Titulo_Traduccion

	#Preferancias para guardar y abrir archivo
	#self.__archivo_name = None
        #self.__salida_name = None
	#self.__homeconfig = environ['HOME'] + '/.config/Traductor/Traductor.conf'
	#self.__configuracion = config(self.__homeconfig)
        #self.__ruta_salvar = self.__configuracion.ShowValueItem("files","save")
        
        #self.__ruta_abrir = self.__configuracion.ShowValueItem("files","open")
        #ruta_abrir = splitfields(self.__ruta_abrir,"/")[0]
        #if ruta_abrir == "$HOME" :
        #    ruta_relativa = splitfields(self.__ruta_abrir,"$HOME")
        #    self.__ruta_abrir = environ['HOME'] + ruta_relativa[-1]
        #ruta_salvar = splitfields(self.__ruta_salvar,"/")[0]
        #if ruta_salvar == "$HOME":
        #    ruta_relativa = splitfields(self.__ruta_salvar,"$HOME")
        #    self.__ruta_salvar = environ["HOME"] + ruta_relativa[-1]
        #self.__paginas = self.__configuracion.ShowValueItem("files","pages")
        #self.__documentos = self.__configuracion.ShowValueItem("documents","document")
        #self.__formato_audio = self.__configuracion.ShowValueItem("documents","audio")
        #self.__interface_idioma = self.__configuracion.ShowValueItem("language","interface")
        #self.__documentos_idioma = self.__configuracion.ShowValueItem("language","document")
	#Valores por defecto interface
        #self.__archivo_url.set_text(self.__ruta_abrir)
        #self.__sel_archivo.set_current_folder_uri(self.__ruta_abrir)
        #self.__salida_url.set_text(self.__ruta_salvar)
        #self.__sel_salida.set_current_folder_uri(self.__ruta_salvar)

    def Nuevo(self):
	self.char_count = self.buffer.get_char_count()
	self.char_count1 = self.buffer1.get_char_count()
	if self.char_count!=0 or self.char_count1!=0:
		self.Salir_Guardar.set_title("Lazarillo - Salir del archivo")
		self.Salir_Guardar.run()
		
    def on_Descartar_clicked(self,*args):
	#Al abrir nuevo archivo, se limpia el buffer y el clipboard,
	#A su vez, el monitor del sistema debería desactivar algunas
	#opciones de la aplicación, p.e: el botón copiar.
	self.Salir_Guardar.hide()
	self.clipboard.clear()
	startiter, enditer = self.buffer.get_bounds()
	self.buffer.delete(startiter,enditer)
	self.Traductor1.set_title("Sin nombre - Lazarillo")
	
	start, end = self.buffer1.get_bounds()
	self.buffer1.delete(start,end)
	self.Titulo_Traduccion.set_text("Sin nombre - Traducción")

    def on_Si_clicked(self,*args):
	#Va a guardar el archivo
	self.Salir_Guardar.hide()
	Util.m_Matematica(self)

    def on_No_clicked(self,*args):
	self.Salir_Guardar.hide()

    """Funciones de la ventana salir sin guardar o guardar los cambios realizados en el documento"""
    def Salir_Guardar(self):
	self.Salir_Guardar.run()
	self.Salir_Guardar.hide()

    """Abrir archivo"""
    #Función Abrir archivo ejecutada desde el menú
    def m_Abrir(self,Traduccion):
	if Traduccion == False:
		# Crea la ventana de selección de Abrir archivo
		self.seleccionar = gtk.FileChooserDialog("Lazarillo - Abrir archivo",action=gtk.FILE_CHOOSER_ACTION_OPEN,buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_OPEN,gtk.RESPONSE_OK))
		self.seleccionar.set_default_response(gtk.RESPONSE_OK)
		self.seleccionar.set_icon_from_file("/usr/local/share/pixmaps/Lazarillo.png")
	
		# Se crean los filtros de selección de archivos
	
		# Filtro 1
		self.filtro = gtk.FileFilter()
		self.filtro.set_name("Texto")
		self.filtro.add_pattern("*.om")
		self.filtro.add_pattern("*.tc")
		self.filtro.add_pattern("*.py")
		self.filtro.add_pattern("*.txt")
		self.filtro.add_pattern("*.sxw")
		self.filtro.add_pattern("*.odt")
		self.filtro.add_pattern("*.doc")
		self.filtro.add_pattern("*.docx")
		self.seleccionar.add_filter(self.filtro)
	
		#Se corre "Abrir archivo"
		self.respuesta = self.seleccionar.run()
		
		if self.respuesta == gtk.RESPONSE_OK:
			#Se obtiene el nombre del archivo
			self.Nombre_Archivo = self.seleccionar.get_filename()
			try:
				xml_document = minidom.parse(self.Nombre_Archivo)
				title_loaded = False
				text_loaded = False
				#Itera a través de los nodos hijos de la raíz
				for node in xml_document.documentElement.childNodes:
				#Se busca el nodo Content
					if (node.nodeName == self._xml_tags[CONTENT_TAG]):
						# Ahora se itera a través de los hijos de Content
						for item_node in node.childNodes:
							if (item_node.nodeName == self._xml_tags[TITLE_TAG]):
								#Carga el título
								if (item_node.firstChild):
									self.Traductor1.set_title(item_node.firstChild.nodeValue)
								else:
									self.Traductor1.set_text("")
								title_loaded = True
							elif (item_node.nodeName == self._xml_tags[TEXT_TAG]):
								#Carga el texto
								if (item_node.firstChild):
									self.lista = item_node.firstChild.nodeValue 
									#Se recorre la lista y se coloca el contenido en un buffer
									i=0
									#Se inicializa el buffer
									startiter, enditer = self.buffer.get_bounds()
									self.buffer.delete(startiter,enditer)
									for i in range (len(self.lista)):
				    						self.buffer.insert_at_cursor(self.lista[i])
				    						#Se coloca el contenido del buffer en el textview
				    						self.Texto.set_buffer(self.buffer)
									del self.lista
								else:
									self.buffer.insert_at_cursor("")
									self.Texto.set_buffer(self.buffer)	
								text_loaded = True
						break
				self.char_count1 = self.buffer1.get_char_count()
				if self.char_count1!=0:
					start, end = self.buffer1.get_bounds()
					self.buffer1.delete(start,end)
					self.Titulo_Traduccion.set_text("Sin nombre - Traducción")

				self.seleccionar.hide()
			except:
				self.path, self.filename= os.path.split(self.Nombre_Archivo)
				Nombre = self.path+"/"+"_"+self.filename
				nomb_arch = "_"+self.filename
				for archivos in os.listdir(self.path):
					if archivos.startswith(nomb_arch):
						os.remove(Nombre)
						break
				lista = open (self.Nombre_Archivo,"r").readlines()
				i=0
				startiter, enditer = self.buffer.get_bounds()
				self.buffer.delete(startiter,enditer)
				for i in range (len(lista)):
				    self.buffer.insert_at_cursor(lista[i])
				self.Nombre_Archivo = self.path+"/"+"_"+self.filename
				del lista
				self.Traduccion = False
				self.bandera = False
				Util.Guardar_Archivo(self,self.Nombre_Archivo,self.buffer,self.filename,self.path)
				#print self.Nombre_Archivo
				xml_document = minidom.parse(self.Nombre_Archivo)
				title_loaded = False
				text_loaded = False
				for node in xml_document.documentElement.childNodes:
					if (node.nodeName == self._xml_tags[CONTENT_TAG]):
						for item_node in node.childNodes:
							if (item_node.nodeName == self._xml_tags[TITLE_TAG]):
								if (item_node.firstChild):
									self.Traductor1.set_title(item_node.firstChild.nodeValue)
								else:
									self.Traductor1.set_text("")
								title_loaded = True
							elif (item_node.nodeName == self._xml_tags[TEXT_TAG]):
								if (item_node.firstChild):
									self.lista = item_node.firstChild.nodeValue 
									i=0
									startiter, enditer = self.buffer.get_bounds()
									self.buffer.delete(startiter,enditer)
									for i in range (len(self.lista)):
				    						self.buffer.insert_at_cursor(self.lista[i])
				    						self.Texto.set_buffer(self.buffer)
									del self.lista
								else:
									self.buffer.insert_at_cursor("")
									self.Texto.set_buffer(self.buffer)	
								text_loaded = True
						break
				self.char_count1 = self.buffer1.get_char_count()
				if self.char_count1!=0:
					start, end = self.buffer1.get_bounds()
					self.buffer1.delete(start,end)
					self.Titulo_Traduccion.set_text("Sin nombre - Traducción")
				self.seleccionar.hide()

		elif self.respuesta == gtk.RESPONSE_CANCEL:
			self.seleccionar.hide()

	elif Traduccion == True:
		self.seleccionar = gtk.FileChooserDialog("Lazarillo - Abrir Traducción",action=gtk.FILE_CHOOSER_ACTION_OPEN,buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_OPEN,gtk.RESPONSE_OK))
		self.seleccionar.set_default_response(gtk.RESPONSE_OK)
	
		# Se crean los filtros de selección de archivos
	
		# Filtro 1
		self.filtro = gtk.FileFilter()
		self.filtro.set_name("Braille")
		self.filtro.add_pattern("*.brl")
		self.seleccionar.add_filter(self.filtro)		
		self.respuesta = self.seleccionar.run()
		
		if self.respuesta == gtk.RESPONSE_OK:
			self.Nombre_Archivo = self.seleccionar.get_filename()
			xml_document = minidom.parse(self.Nombre_Archivo)
			title_loaded = False
			text_loaded = False
			#Itera a través de los nodos hijos de la raíz
			for node in xml_document.documentElement.childNodes:
			#Se busca el nodo Content
				if (node.nodeName == self._xml_tags[CONTENT_TAG]):
					# Ahora se itera a través de los hijos de Content
					for item_node in node.childNodes:
						if (item_node.nodeName == self._xml_tags[TITLE_TAG]):
							#Carga el título
							if (item_node.firstChild):
								self.Titulo_Traduccion.set_text(item_node.firstChild.nodeValue)
							else:
								self.Titulo_Traduccion.set_text("")
							title_loaded = True
						elif (item_node.nodeName == self._xml_tags[TEXT_TAG]):
							#Carga el texto
							if (item_node.firstChild):
								self.lista = item_node.firstChild.nodeValue 
								#Se recorre la lista y se coloca el contenido en un buffer
								i=0
								#Se inicializa el buffer
								startiter, enditer = self.buffer1.get_bounds()
								self.buffer1.delete(startiter,enditer)
								for i in range (len(self.lista)):
			    						self.buffer1.insert_at_cursor(self.lista[i])
			    						#Se coloca el contenido del buffer en el textview
			    						self.Texto_Traduccion.set_buffer(self.buffer1)
								del self.lista
								start, end = self.buffer1.get_bounds()
								self.tag = self.buffer1.create_tag(None)
								self.tag.set_property("font", "Braile font 28")
								self.buffer1.apply_tag(self.tag, start, end)
								self.Texto_Traduccion.set_editable(False)
							else:
								self.buffer1.insert_at_cursor("")
								self.Texto_Traduccion.set_buffer(self.buffer1)	
							text_loaded = True
					break
			self.seleccionar.hide()

		elif self.respuesta == gtk.RESPONSE_CANCEL:
				self.seleccionar.hide()

    """-----------Guardar archivo------------"""
    def Guardar_Archivo(self,*args):
	Nombre = "_" + self.filename
	for archivos in os.listdir(self.path):
	#Para el caso en que el _filename ya exista
		if archivos.startswith(Nombre):
			self.bandera = True
			self.Nombre_Archivo=self.path+"/"+"_"+self.filename
			Util.Guardar(self,self.Nombre_Archivo,self.path,self.filename)
			self.Nombre_Archivo = self.path + "/" + self.filename
			Original = open (self.Nombre_Archivo,"w")
			Original.write(self.text)
			Original.close()
			break
	if self.bandera==False:#problema con bandera
		Util.Guardar(self,self.Nombre_Archivo,self.path,self.filename)
			
    """Para guardar en XML"""
    def Guardar(self,*args):
	#Obtiene el DOM Implementation disponible
	impl = minidom.getDOMImplementation()
	#Crea el documento, con Traductor como nodo base
	xml_document = impl.createDocument(None, self._xml_tags[MAIN_TAG], None)
	#Ahora trata de guardar el archivo
	try:
		self.fescritura=open(self.Nombre_Archivo,'w')
		#Primero crea el elemento xml Content
		#Crea <Content></Content>
		content_element = xml_document.createElement(self._xml_tags[CONTENT_TAG])
		
		#Para guardar la traducción
		if self.Traduccion == True:
			#Title
			title = self.filename+" ("+self.path+")"+" - Traducción"
			#Text
			self.text = self.buffer1.get_text(self.buffer1.get_start_iter(), self.buffer1.get_end_iter())
			#Crea <title></title>
			title_element = xml_document.createElement(self._xml_tags[TITLE_TAG])
			#Crea <title>title text</title>
			title_element.appendChild(xml_document.createTextNode(title))
			#Crea <text></text>
			text_element = xml_document.createElement(self._xml_tags[TEXT_TAG])
			#Crea <text>text</text>
			text_element.appendChild(xml_document.createTextNode(self.text))
			#Ahora crea <Content><title>title text</title><text>text</text></Content>
			content_element.appendChild(title_element)
			content_element.appendChild(text_element)
			#Ahora se agrega al documento xml
			xml_document.documentElement.appendChild(content_element)
        		#Escribe el documento xml en el disco
			xml_document.documentElement.writexml(self.fescritura)
			self.Titulo_Traduccion.set_text(self.filename +" ("+self.path+")"+" - Traducción")
		
		elif self.Traduccion == False:
			#Title		
			title = self.filename+" ("+self.path+")"+" - Lazarillo"
			#print self.buffer.get_char_count()
			#Text
			self.text = self.buffer.get_text(self.buffer.get_start_iter(), self.buffer.get_end_iter())
			#print self.text
			#Crea <title></title>
			title_element = xml_document.createElement(self._xml_tags[TITLE_TAG])
			#Crea <title>title text</title>
			title_element.appendChild(xml_document.createTextNode(title))
			#Crea <text></text>
			text_element = xml_document.createElement(self._xml_tags[TEXT_TAG])
			#Crea <text>text</text>
			text_element.appendChild(xml_document.createTextNode(self.text))
			#Ahora crea <Content><title>title text</title><text>text</text></Content>
			content_element.appendChild(title_element)
			content_element.appendChild(text_element)
			#Ahora se agrega al documento xml
			xml_document.documentElement.appendChild(content_element)
        		#Escribe el documento xml en el disco
			xml_document.documentElement.writexml(self.fescritura)
			self.Traductor1.set_title(self.filename +" ("+self.path+")"+" - Lazarillo")
		self.fescritura.close()
	except IOError, (errno):
		self.Error.set_title("Error al guardar")
		self.Error.set_markup("Error guardando el documento: %s" % errno)
		Util.on_Error(self,*args)

    """Guardar por el menú"""
    #NOTA: el archivo debe tener una extensión
    def m_Matematica(self,*args):
	self.Traduccion = False
	#Por medio del título, puedo obtener la ubicación del archivo
	Titulo = self.Traductor1.get_title()
	#Caso 1: Guardar archivo existente
	if Titulo != "Sin nombre - Lazarillo": 
		#Obtengo el nombre de archivo y la ruta
		filename1,parentesis,resto = Titulo.partition("(")
		ruta,espacio,resto = resto.partition(" ")
		Camino = ruta.rstrip(" - Lazarillo")
		Camino1= Camino.rstrip(")")
		self.path= Camino1.lstrip("(")
		self.filename = filename1.rstrip(" ")
		for archivo in os.listdir(self.path):
			if archivo.startswith(self.filename):
				self.Nombre_Archivo = self.path + "/" +self.filename
				self.bandera = False #Para confirmar que no es un archivo importado
				Util.Guardar_Archivo(self,self.Nombre_Archivo)
	else:			
		self.selector = gtk.FileChooserDialog("Lazarillo - Guardar archivo",None,gtk.FILE_CHOOSER_ACTION_SAVE,(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,gtk.STOCK_SAVE, gtk.RESPONSE_OK))
        	self.selector.set_default_response(gtk.RESPONSE_OK)
		self.selector.set_icon_from_file("/usr/local/share/pixmaps/Lazarillo.png")
		#A veces pasa esto:MatematicaBraille.py:335: GtkWarning: gtk_tree_selection_select_iter: assertion `selection->tree_view->priv->model != NULL' failed
  		#self.resultado = self.selector.run()
		self.resultado = self.selector.run()
		if self.resultado == gtk.RESPONSE_OK:
			#Se separa la ruta y el nombre de archivo
			self.path, self.filename= os.path.split(self.selector.get_filename())
			
			#Caso 2: Reemplazar archivo
			for archivos in os.listdir(self.path):
				#Si el nombre de archivo suministrado es igual a uno existente, preguntar si desea reemplazarlo
				if self.Traductor1.get_title()=="Sin nombre - Lazarillo" and archivos.startswith(self.filename):
					self.selector.hide()
					self.Pregunta_accion.set_title("Lazarillo - Guardar")
					#Se corre la ventana de Pregunta
					Util.on_Pregunta_accion(self)
					break
			#Caso 3: Guardar un archivo nuevo
			self.bandera = False #Para confirmar que no es un archivo importado
			self.Nombre_Archivo= self.selector.get_filename()
			Util.Guardar_Archivo(self)
			self.selector.hide()
		elif self.resultado == gtk.RESPONSE_CANCEL:
			self.selector.hide()	
        

    def m_Traduccion(self,*args):
	#Se guarda la traducción con el mismo nombre del archivo orginal
	self.Traduccion = True
	Titulo = self.Traductor1.get_title()
	if Titulo != "Sin nombre - Lazarillo": #self.bandera == False
		#Obtengo el nombre de archivo y la ruta
		filename1,parentesis,resto = Titulo.partition("(")
		ruta,espacio,resto = resto.partition(" ")
		Camino = ruta.rstrip(" - Lazarillo")
		Camino1= Camino.rstrip(")")
		self.path= Camino1.lstrip("(")
		self.filename = filename1.rstrip(" ")
		self.Nombre,punto,ext = self.filename.partition(".")
		self.filename =  self.Nombre + ".brl"
		self.Nombre_Archivo = self.path + "/" +self.filename
		print self.Nombre_Archivo
		self.bandera = False #Para confirmar que no es un archivo importado
		Util.Guardar_Archivo(self,self.Nombre_Archivo)
	else:			
		
		self.Error.set_title("Lazarillo - Error al Guardar")
		self.Error.set_markup("Primero debe guardar el archivo editado")
		Util.on_Error(self,*args)		

    def m_Guardar_C_Texto(self):
	self.bandera = False
	self.Traduccion = False
	Titulo = self.Traductor1.get_title()
	#Si se quiere guardar la copia del un archivo existente con otro nombre
	if Titulo != "Sin nombre - Lazarillo":
		self.selector = gtk.FileChooserDialog("Lazarillo - Guardar como",None,gtk.FILE_CHOOSER_ACTION_SAVE,(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,gtk.STOCK_SAVE, gtk.RESPONSE_OK))
        	self.selector.set_default_response(gtk.RESPONSE_OK)
		self.selector.set_icon_from_file("/usr/local/share/pixmaps/Lazarillo.png")
		filename1,espacio,resto = Titulo.partition(" ")
		#Muestra el nombre actual del archivo
		self.selector.set_filename(filename1)
		self.resultado = self.selector.run()
		if self.resultado == gtk.RESPONSE_OK:
			#Se separa la ruta y el nombre de archivo
			self.path, self.filename= os.path.split(self.selector.get_filename())
			#Caso 2: Reemplazar archivo
			for archivos in os.listdir(self.path):
				#Si el nombre de archivo suministrado es igual a uno existente, preguntar si desea reemplazarlo
				if archivos.startswith(self.filename):
					self.selector.hide()
					self.Pregunta_accion.set_title("Lazarillo - Guardar como")
					#Se corre la ventana de Pregunta
					self.bandera = False
					Util.on_Pregunta_accion(self)
					break
			self.Nombre_Archivo = self.path +"/"+self.filename
			Util.Guardar_Archivo(self)
			self.selector.hide()
        		
		elif self.resultado == gtk.RESPONSE_CANCEL:
			self.selector.hide()
	#Sino, se envía a guardar como cualquier archivo nuevo
	else:
		Util.m_Matematica(self)

    def m_Guardar_C_Traduccion(self):
	self.bandera = False
	self.Traduccion = True
	Titulo = self.Titulo_Traduccion.get_text()
	#Si se quiere guardar la copia del un archivo existente con otro nombre
	if Titulo != "Sin nombre - Traducción":
		self.selector = gtk.FileChooserDialog("Lazarillo - Guardar como",None,gtk.FILE_CHOOSER_ACTION_SAVE,(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,gtk.STOCK_SAVE, gtk.RESPONSE_OK))
       		self.selector.set_default_response(gtk.RESPONSE_OK)
		filename1,espacio,resto = Titulo.partition(" ")
		#Muestra el nombre actual del archivo
		self.selector.set_filename(filename1)
		self.resultado = self.selector.run()
		if self.resultado == gtk.RESPONSE_OK:
			#Se separa la ruta y el nombre de archivo
			self.path, self.filename= os.path.split(self.selector.get_filename())
			if self.filename.endswith(".brl") == False:
				self.filename = self.filename + ".brl"

			#Caso 2: Reemplazar archivo
			for archivos in os.listdir(self.path):
				#Si el nombre de archivo suministrado es igual a uno existente, preguntar si desea reemplazarlo
				if archivos.startswith(self.filename):
					self.selector.hide()
					self.Pregunta_accion.set_title("Lazarillo - Guardar como")
					#Se corre la ventana de Pregunta
					self.bandera = False
					Util.on_Pregunta_accion(self)
					break
			self.Nombre_Archivo = self.path +"/"+self.filename
			Util.Guardar_Archivo(self)
			self.selector.hide()
        		
		elif self.resultado == gtk.RESPONSE_CANCEL:
			self.selector.hide()
	#Sino, se envía a guardar como cualquier archivo nuevo
	else:
		Util.m_Matematica(self)

    """Funciones de la ventana de Preguntas con boton Aceptar configurado"""
    #Ventana de pregunta específica para preguntar si se desea reemplazar un archivo
    def on_Pregunta_accion(self):
	self.Pregunta_accion.set_icon_from_file("/usr/local/share/pixmaps/Lazarillo.png")
	self.Pregunta_accion.run()
	self.Pregunta_accion.hide()

    #Se ejecuta el reemplazo del archivo
    def on_Aceptar_P_clicked(self,*args):
	self.Nombre_Archivo = self.path+'/'+self.filename
	Util.Guardar_Archivo(self)
	
    def on_Cancelar_P_clicked(self,*args):
	self.Pregunta_accion.hide()
	Util.m_Matematica(self)

    """-----------Cambiar Traducción-------------"""
    #Ventana que permite elegir el tipo de traducción a la que se desa cambiar
    def on_Cambiar_Traduccion(self,bandera):
	self.bandera = bandera
	if self.bandera == True:
		self.Traducir_Texto.set_sensitive(False)
	elif self.bandera == False:
		self.Traducir_Operaciones_Matematicas.set_sensitive(False)
    	self.Cambiar_Traduccion.run()
	self.Cambiar_Traduccion.hide()

    #Configuracion del botón aceptar de la ventana Cambiar_Traduccion
    def on_Acept1_clicked(self,*args):
	res1 = self.Traducir_Texto.get_active()
	res2 = self.Traducir_Operaciones_Matematicas.get_active()
	if res1 == True:
		self.Cambiar_Traduccion.hide()
		from MatematicaBraille import Traductor
		Inst = Traductor()
		#Inst.on_Traductor_destroy(self,*args)
		Inst.Traductor.hide()
		from CastellanoBraille import Castellano
		Instancia = Castellano()
		Instancia.main(self,*args)
				
	elif res2 == True:
		self.Cambiar_Traduccion.hide()
		from CastellanoBraille import Castellano
		Inst = Castellano()
		#Inst.on_Castellano_destroy(self,*args)
		Inst.Castellano.hide()
		from MatematicaBraille import Traductor
		Instancia = Traductor()
		Instancia.main(self,*args)
		
	self.Cambiar_Traduccion.hide()

    def on_Cancel1_clicked(self,*args):
	self.Cambiar_Traduccion.hide()

    """------------Elegir Perfil------------"""
    """Funciones de la ventana Elegir_Perfil"""
    #Ventana que permite elegir un nuevo perfil de usuario
    def on_Elegir_Perfil(self,*args):
	self.Elegir_Perfil.run()
	self.Elegir_Perfil.hide()

    #Carga el contenido elegido en la ventana Elegir_Perfil
    def on_Acepta_clicked(self,*args):
	res1 = self.Usuario_Invidente.get_active()
	res2 = self.Usuario_Baja_V.get_active()
	res3 = self.Usuario_Vidente.get_active()
	if res1 == True:
		self.Elegir_Perfil.hide()
		Util.Orca(self)		
	
	elif res2 == True:
		self.Elegir_Perfil.hide()
		Util.Magnificador(self)

	elif res3 == True:
		self.Elegir_Perfil.hide()
		Util.Matar_Orca(self,*args)		

	self.Elegir_Perfil.hide()

    """Imprimir"""
    #Hay que elegir entre impresora Braille y la normal
    #def m_Imprimir (self,*args):
    #	self.Imprimir = gtk.PrintSettings()
	
	
    """Salir por el menú"""
    #Salir de la aplicación por el menú
    def m_Salir(self):
	self.Preguntas.set_title("Salir")
        self.Preguntas.set_markup("¿Desea salir de Lazarillo?")
	result = self.Preguntas.run()
        if result == -5:
	    sys.exit(1)
        else:
            self.Preguntas.hide()

    """Funciones de edición"""
    #Función deshacer ejecutada desde el menú, tomada desde gtksourceview
    def m_Deshacer(self):
	if self.buffer.can_undo():
        	self.buffer.undo()

    #Función rehacer ejecutada desde el menú, tomada desde gtksourceview
    def m_Rehacer(self):
	#Chequear cuando Rehacer está vacío
	if self.buffer.can_redo():
        	self.buffer.redo()

    #Función Cortar ejecutada desde el menú
    def m_Cortar(self):
	self.buffer.cut_clipboard(self.clipboard,self.Texto.get_editable())

    #Función Copiar ejecutada desde el menú
    def m_Copiar(self):
	self.buffer.copy_clipboard(self.clipboard)

    #Función Pegar ejecutada desde el menú
    def m_Pegar(self):
	self.buffer.paste_clipboard(self.clipboard,None,self.Texto.get_editable())
 
    #Función ejecutada desde el menú, selecciona todo el contenido del archivo
    def m_Seleccionar_todo(self):
	start, end = self.buffer.get_bounds()
	#Se crean las marcas iniciales y se obtiene el texto del buffer           
    	self.buffer.create_mark("Start",start,True)     
    	self.buffer.create_mark("End",end,True)
    	text=self.buffer.get_text(start,end,True)
	self.buffer.delete_selection(False,False)
	#Se "sincronizan" las marcas anteriores con las designadas para seleccionar texto
    	iter_start=self.buffer.get_iter_at_mark(self.buffer.get_mark("Start"))
    	iter_end=self.buffer.get_iter_at_mark(self.buffer.get_mark("End"))
	#Se selecciona el texto contenido en las marcas    
    	self.buffer.move_mark_by_name("insert",iter_start)         
    	self.buffer.move_mark_by_name("selection_bound",iter_end)

    #Del menú Buscar: Ir a
    def m_Ir_a(self,*args):
	self.V_Ir_a.set_title("Lazarillo - Ir a línea")
	Util.on_V_Ir_a(self,*args)

    def on_Aceptar3_clicked(self,*args):
	linea = self.Entrada_num.get_text()
	Cuenta = self.buffer.get_line_count()
	if linea.isdigit()==False:
		self.Error.set_title("Lazarillo - Error")
		self.Error.set_markup("Debe suministrar un número de línea válido")
		Util.on_Error(self,*args)

	elif  int(linea)>Cuenta or int(linea)<=0:
		self.Error.set_title("Lazarillo - Error")
		self.Error.set_markup("Número de línea incorrecto")
		Util.on_Error(self,*args)
	else:
		lin = int(linea)-1		
		start, end = self.buffer.get_bounds()
		start.set_line(lin)
		self.buffer.create_mark("Start",start,True)     
    		self.buffer.create_mark("End",end,True)
    		start=self.buffer.get_iter_at_mark(self.buffer.get_mark("Start"))
    		end=self.buffer.get_iter_at_mark(self.buffer.get_mark("End"))
    		self.buffer.move_mark_by_name("insert",start)         
    		self.buffer.move_mark_by_name("selection_bound",end)
		self.buffer.place_cursor(start)

    def on_V_Ir_a(self,*args):
	self.V_Ir_a.run()
	self.V_Ir_a.hide()

    def on_M_Ayuda(self,*args):
    	self.M_Ayuda.run()
    	self.M_Ayuda.hide()

    def on_Cerrar_clicked(self,*args):
	self.M_Ayuda.hide()
	
    #Muestra el Manual de Ayuda del sistema
    def m_Manual_Ayuda(self):
	self.lista=[]
	f = open('Ayuda.txt','r')

	while True:
		self.linea = f.readline()
		if not self.linea: break
		self.lista.append(self.linea)

	for i in range (len(self.lista)):
		self.buffer_cont.insert_at_cursor(self.lista[i])
	self._Ayuda.set_buffer(self.buffer_cont)
	del self.lista
	f.close()
	self.M_Ayuda.show()
	

    #Muestra informarción sobre el sistema
    def m_Acerca_de(self):
	self.Acerca_de.run()
	self.Acerca_de.hide()

    #Permite activar o desactivar desde la aplicación las funcionalidades brindadas por ORCA: Lector de pantalla y magnificador

    def Matar_Orca(self,*args):
       	p = Popen(["orca","-q"],bufsize=0,stdin=PIPE, stdout=PIPE, close_fds=True)
	(child_stdin, child_stdout) = (p.stdin, p.stdout)

    def Orca(self):
	p = Popen(["orca","-e","speech"],bufsize=0,stdin=PIPE, stdout=PIPE, close_fds=True)
	(child_stdin, child_stdout) = (p.stdin, p.stdout)

    def Magnificador(self):
	Util.Matar_Orca(self)	
	p = Popen(["orca","-e","magnifier"],bufsize=0,stdin=PIPE, stdout=PIPE, close_fds=True)
	(child_stdin, child_stdout) = (p.stdin, p.stdout)

    """-----------Misceláneos--------------"""	
    """Funciones de la ventana de Preguntas"""
    #Ventana genérica de preguntas
    def on_Preguntas(self, *args):
	self.Preguntas.run()
	self.Preguntas.hide()
    
    """Funciones de la ventana de Error"""
    #Ventana genérica para anunciar un error al usuario
    def on_Error(self, *args):
	self.Error.run()
	self.Error.hide()

